home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / PROGRAMM / PROGEDIT / 3528.ZIP / CBX300.EXE / CANSI.LNG < prev    next >
Text File  |  1991-05-10  |  19KB  |  627 lines
  1. ?≡«»≤≥
  2. «function-definition»
  3.  
  4.  
  5. ?«function-definition»
  6. «bios.h»
  7. #include <bios.h>;
  8. «conio.h»
  9. #include <conio.h>;
  10. «ctype.h»
  11. #include <ctype.h>;
  12. «dos.h» «dos.h_2» «dos.h_3»
  13. #include <dos.h>;
  14. «direct.h»
  15. #include <direct.h>;
  16. «float.h»
  17. #include <float.h>;
  18. «graphics.h»
  19. #include <graphics.h>;
  20. «io.h»
  21. #include <io.h>;
  22. «malloc.h» «malloc.h-FAR» «malloc.h-FAR-STRING»
  23. #include <malloc.h>;
  24. «math.h»
  25. #include <math.h>;
  26. «memory.h»
  27. #include <memory.h>;
  28. «process.h»
  29. #include <process.h>;
  30. «search.h»
  31. #include <search.h>;
  32. «setjmp.h»
  33. #include <setjmp.h>;
  34. «signal.h»
  35. #include <signal.h>;
  36. «stdio.h-ANSI» «stdio.h»
  37. #include <stdio.h>;
  38. «stdlib.h-ANSI» «stdlib.h»
  39. #include <stdlib.h>;
  40. «string.h-ANSI» «string.h»
  41. #include <string.h>;
  42. «time.h»
  43. #include <time.h>;
  44.  
  45.  
  46.  
  47. ?«stdio.h-ANSI»
  48. void clearerr(FILE *fp);
  49. int fclose(FILE *fp);
  50. int feof(FILE *fp);
  51. int ferror(FILE *fp);
  52. int fflush(FILE *fp);
  53. int fgetc(FILE *fp);
  54. int fgetpos(FILE *fp,fpos_t *pos);
  55. char *fgets(char *buffer,int n,FILE *fp);
  56. FILE *fopen(char *filename,char*access);
  57. int fprintf(FILE *fp,char *format,...);
  58. int fputc(int c,FILE *fp);»
  59. int fputs(char *string,FILE *fp);
  60. size_t fread(void *buffer,size_t size,size_t number,FILE *fp);
  61. FILE *freopen(char *filename,char *mode,FILE *fp);
  62. int fscanf(FILE *fp,char*fs,...);
  63. int fseek(FILE *fp,long offset,int origin);
  64. int fsetpos(FILE *fp,fpos_t *pos);
  65. long ftell(FILE *fp);
  66. size_t fwrite(void *buffer,size_t size,size_t number,FILE *fp);
  67. int getc(FILE *fp);
  68. char *gets(char*buffer);
  69. void perror(char*string);
  70. int printf(char *format,...);
  71. int putc(int c,FILE *fp);
  72. int puts(char*string);
  73. int remove(char *filename);
  74. int rename(char *oldname,char *newname);
  75. void rewind(FILE *fp);
  76. int scanf(char *format,...);
  77. void setbuf(FILE *fp,char*bufptr);
  78. int setvbuf(FILE *fp,char *bufptr,int buftype,size_tbufsize);
  79. int sprintf(char *s,char *format,...);
  80. int sscanf(char *s,char *format,...);
  81. FILE *tmpfile(void);
  82. char *tmpnam(char*buffer);
  83. int ungetc(int c,FILE *fp);
  84. int vfprintf(FILE *fp,char *format,va_listarglist);
  85. int vprintf(char *format,va_listarglist);
  86. int vsprintf(char *s,char *format,va_listarglist);
  87.  
  88.  
  89. ?«stdio.h»
  90. #include<stdio.h>;
  91. int fcloseall(void);
  92. FILE *fdopen(int fd,char *mode);
  93. int fileno(FILE *fp);
  94. int flushall(void);
  95. int fputchar(int c);
  96. int getw(FILE *fp);
  97. int putw(int word,FILE*fp);
  98. int rmtmp(void);
  99. char*tempnam(char *dir,char *prename);
  100. int unlink(char *filename);
  101.  
  102.  
  103. ?«stdlib.h-ANSI»
  104. #include <stdlib.h>;
  105. void abort(void);
  106. intabs(int n);
  107. int atexit(void (*funcptr)(void));
  108. double atof(char*string);
  109. int atoi(char*string);
  110. long atol(char*string);
  111. void *bsearch(void *key,void *base,size_t number,size_t size,
  112. int (*compare)(void *,void *));
  113. void *calloc(size_t number,size_t size);
  114. div_t div(int numer,int denom);
  115. void exit(int status);
  116. void free(void *ptr);
  117. char *getenv(char *name);
  118. long labs(long n);
  119. ldiv_t ldiv(long numer,long denom);
  120. void *malloc(size_t size);
  121. void qsort(void *base,size_t number,size_t size,int(*compare)(void *, void *));
  122. int rand(void);
  123. void *realloc(void *ptr,size_t size);
  124. void srand(unsigned seed);
  125. double strtod(char *str,char **scanstop);
  126. long strtol(char *str,char **scanstop,int base);
  127. unsigned long strtoul(char *str,char **scanstop,int base);
  128. int system(char*cmdstring);
  129.  
  130.  
  131.  
  132. ?«stdlib.h»
  133. #include <stdlib.h>;
  134. double drand(int n);
  135. char *ecvt(double x,int digits,int *decimal,int *sign);
  136. void _exit(int status);
  137. char *fcvt(double x,int digits,int *decimal,int *sign);
  138. void ftoa(double x,char *buffer,unsigned flag,unsigned left,unsigned right);
  139. char *gcvt(double x,int digits,char*buffer);
  140. char *itoa(int value,char *digits,int base);
  141. char *ltoa(long value,char *digits,int base);
  142. onexit_t onexit(onexit_tfuncptr);
  143. char *putenv(char*string);
  144. void swab(char *source,char *destination,int n);
  145. char *ultoa(unsigned long value,char *digits,int base);
  146.  
  147.  
  148. ?«string.h-ANSI»
  149. #include <string.h>;
  150. void *memchr(void *addr  ,size_t n);
  151. int memcmp(void *addr1,void *ad>L^  
  152. int memcpy(void *destaddr,void *srcaddr,size_t mL^  ve(void *destaddr,void *srcaddr,size_t n);
  153. void *memsíL^  ,int c,size_t n);
  154. char *strcat(char *str1,char *str2);
  155. char *strchr(char *str,int c);
  156. int strcmp(char *str1,char *str2);
  157. char *strcpy(char *str1,char *str2);
  158. size_t strcspn(char *str1,char *str2);
  159. char *strerror(int errno);
  160. size_t strlen(char *str);
  161. char *strncat(char *str1,char *str2,size_t n);
  162. int strncmp(char *str1,char *str2,size_t n);
  163. char *strncpy(char *str1,char *str2,size_t n);
  164. char *strpbrk(char *str1,char *str2);
  165. char *strrchr(char *str,int c);
  166. size_t strspn(char *str1,char *str2);
  167. char *strstr(char *str1,char *str2);
  168. char *strtok(char *str1,char*str2);
  169.  
  170.  
  171. ?«string.h»
  172. #include <string.h>;
  173. void *memccpy(void *destaddr,void *srcaddr,int c,size_t n);
  174. int memicmp(void *addr1,void *addr2,size_t n);
  175. void movedata(int srcseg,int srcoff,int destseg,int destoff,unsigned size);
  176. void movmem(void *srcaddr,void *destaddr,size_t n);
  177. void repmem(void *address,void *data,int size,int number);
  178. char *stpcpy(char *str1,char *str2);
  179. int strcmpi(char *str1,char *str2);
  180. char *strdup(char *str);
  181. char *stristr(char *str1,char *str2);
  182. char *strlwr(char *str);
  183. int strnicmp(char *str1,char *str2,size_t n);
  184. char *strnset(char *str,int c,size_t n);
  185. char *strrev(char *str);
  186. char *strset(char *str,int c);
  187. char *strupr(char *str);
  188.  
  189.  
  190. ?«conio.h»
  191. #include<conio.h>;
  192. char *cgets(char string[]);
  193. int cprintf(char*format,...);
  194. void cputs(char*string);
  195. int cscanf(char*format,...);
  196. int getch(void);
  197. int getche(void);
  198. intgetkey(void);
  199. char *getpass(char*prompt);
  200. int inp(unsigned port);
  201. int inport(int port);
  202. int inportb(int port);
  203. int kbhit(void);
  204. int outp(unsigned port,int c);
  205. void outport(unsigned port,int word);
  206. void outportb(intport,char c);
  207. void putch(int c);
  208. int ungetch(int c);
  209.  
  210.  
  211. ?«malloc.h»
  212. #include <malloc.h>;
  213. void *alloca(unsigned n);
  214. char *brk(void *endds);
  215. void *calloc(size_t number,size_t size);
  216. unsigned coreleft(void);
  217. void *_expand(void *ptr,int size);
  218. unsigned _freect(unsignedblksize);
  219. void free(void *ptr);
  220. void huge *halloc(longnumber,unsigned size);
  221. void hfree(void huge *ptr);
  222. void *malloc(size_t size);
  223. unsigned _memavl(void);
  224. unsigned _msize(void *ptr);
  225. void _nfree(void near *ptr);
  226. char near *_nmalloc(unsigned size);
  227. unsigned _nmsize(void near *ptr);
  228. void *realloc(void *ptr,size_t size);
  229. char*sbrk(int increment);
  230. unsigned stackavail(void);
  231.  
  232.  
  233. ?«malloc.h-FAR»
  234. #include <malloc.h>;
  235. void far *farcalloc(unsigned long number,unsigned long size);
  236. unsigned long farcoreleft(void);
  237. void farfree(voidfar*ptr);
  238. void far *farmalloc(unsigned long size);
  239. voidfar *farmemccpy(void far *destaddr,
  240.   void far *srcaddr,int c,size_t n);
  241. void far *farmemchr(void far *addr,int c,size_t n);
  242. int farmemcmp(void far*addr1,void far *addr2,size_t n);
  243. int farmemcpy(void far*destaddr,void far *srcaddr,size_t n);
  244. int farmemicmp(void far *addr1,void far *addr2,size_t n);
  245. int farmemmove(void far *destaddr,void far *srcaddr,size_t n);
  246. void far *farmemset(void far *addr,int c,size_t n);
  247. void far *farrealloc(void far *ptr,unsigned long size);
  248. unsigned farsetsize(unsignedmaxsize);
  249. long fartol(void far *ptr);
  250. void _ffree(void far *ptr);
  251. void far *_fmalloc(unsigned size);
  252. unsigned _fmsize(void far *ptr);
  253. void far *ltofar(longaddress);
  254.  
  255.  
  256.  
  257. ?«malloc.h-FAR-STRING»
  258. #include <malloc.h>;
  259. char far *farstrcat(char far *st1,char far *st2);
  260. char far *farstrchr(char far *st,int c);
  261. int farstrcmp(char far*st1,char far *st2);
  262. int farstrcmpi(char far *st1,char far *st2);
  263. charfar *farstrcpy(char far *st1,char far *st2);
  264. size_t farstrcspn(charfar *st1,char far *st2);
  265. char far *farstrdup(charfar *st);
  266. char far*farstristr(char far *st1,char far *st2);
  267. size_t farstrlen(char far*st);
  268. char far *farstrlwr(char far*st);
  269. char far *farstrncat(char far *st1,char far *st2,size_t n);
  270. int farstrncmp(char far *st1,char far *st2,size_t n);
  271. char far *farstrncpy(char far *st1,char far *st2,size_t n);
  272. int farstrnicmp(char far *st1,char far *st2,size_t n);
  273. char far *farstrnset(char far *st,int c,size_t n);
  274. char far *farstrpbrk(char far *st1,char far *st2);
  275. char far *farstrrchr(char far *st,int c);
  276. char far *farstrrev(charfar *st);
  277. char far *farstrset(char far *st,int c);
  278. size_t farstrspn(char far *st1,char far *st2);
  279. char far *farstrstr(char far*st1,char far *st2);
  280. char far *farstrtok(char far *st1,char far *st2);
  281. char far *farstrupr(charfar*st);
  282.  
  283.  
  284. ?«process.h»
  285. #include<process.h>;
  286. void abort(void);
  287. void abort(void);
  288. intexecl(char*filename,char*arg0,...);
  289. int execle(char *filename,char*arg0,...);
  290. int execlp(char *filename,char*arg0,...);
  291. int execlpe(char *filename,char*arg0,...);
  292. int execv(char *filename,char*argv[]);
  293. int execve(char *filename,char *argv[],char*envp[]);
  294. int execvp(char *filename,char*argv[]);
  295. int execvpe(char *filename,char *argv[],char*envp[]);
  296. void exit(int status);
  297. void _exit(int status);
  298. int getpid(void);
  299. intspawnl(int mode,char *filename,char*arg0,...);
  300. int spawnle(int mode,char *filename,char*arg0,...);
  301. int spawnlp(int mode,char *filename,char*arg0,...);
  302. int spawnlpe(int mode,char *filename,char*arg0,...);
  303. int spawnv(int mode,char *filename,char*argv[]);
  304. int spawnve(int mode,char *filename,char *argv[],char*envp[]);
  305. int spawnvp(int mode,char *filename,char*argv[]);
  306. int spawnvpe(int mode,char *filename,char *argv[],char*envp[]);
  307. int system(char *cmdstring);
  308.  
  309.  
  310. ?«bios.h»
  311. #include <bios.h>;
  312. int     bioscom(int operation,char data,intcomport);
  313. int     biosdisk(int operation,char drive,int head,
  314.                  int cylinder,int sector,int nsects,void*buffer);
  315. int     biosequip(void);
  316. int     bioskey(int operation);
  317. int     biosmemory(void);
  318. int     biosprint(int operation,int data,intprnport);
  319. long    biostime(int operation,longnewtime);
  320. void    clrscrn(void);
  321. void    clrscrn2(int attr);
  322. void    cursblk(void);
  323. void    curslin(void);
  324. int     curscol(void);
  325. int     cursrow(void);
  326. void    cursoff(void);
  327. void    curson(void);
  328. int     getvmode(void);
  329. void    poscurs(int row,int col);
  330. int     readattr(void);
  331. int     readch(void);
  332. int     readdot(int row,int col);
  333. void    setcolor(int background,intpalette);
  334. int     setvmode(int mode);
  335. void    sound(int freq,int duration);
  336. void    writech(int c);
  337. void    writechs(int c,int attr,int n);
  338. void    writedot(int row,int col,intpixel);
  339.  
  340.  
  341. ?«dos.h»
  342. #include<dos.h>;
  343. int absread(int drive,int nsects, int sector, void*buffer);
  344. int abswrite(int drive, int nsects, int sector, void*buffer);
  345. int allocmem(unsigned size, unsigned *seg);
  346. int asm(void *codeptr,void *dataptr);
  347. int bdosptr(int fn, void *address, unsigned al);
  348. struct country *country(int code, struct country *info);
  349. void ctrlbrk(int (*handler)(void));
  350. void disable(void);
  351. int dosexterr(struct DOSERROR *errinfo);
  352. time_t dostounix(struct date dosdate, struct timedostime);
  353. void enable(void);
  354. int freemem(unsigned seg);
  355. void geninterrupt(int intno);
  356. int getcbrk(void);
  357. int getcseg(void);
  358. void getdate(struct date *datebuf);
  359. void getdfree(int drive, struct dfree *diskdata);
  360. int getdseg(void);
  361. char far *getdta(void);
  362. void getfat(int drive,struct fatinfo *fat);
  363. void getfatd(struct fatinfo *fat);
  364. unsigned getpsp(void);
  365. void gettime(struct time *timebuf);
  366. void interrupt (far *getvect(int intno))();
  367. int getverify(void);
  368. void harderr(int (*handler)(int error, int ax, int bp,int si));
  369. void hardresume(int cmd);
  370. void hardretn(int error);
  371. int inp(unsigned port);
  372.  
  373.  
  374. ?«dos.h_2»
  375. #include<dos.h>;
  376. int inport(int port);
  377. int inportb(int port);
  378. int int86(int interrupt,union REGS *inregs,union REGS *outregs);
  379. int int86x(int interrupt,union REGS *inregs,union REGS *outregs,
  380.      struct SREGS *segregs);
  381. int intdos(union REGS *inregs,union REGS *outregs);
  382. int intdosx(union REGS*inregs,union REGS *outregs,
  383.      struct SREGS *segregs);
  384. void intr(int interrupt,struct REGPACK *regs);
  385. void keep(int status,int size);
  386. int outp(unsigned port,intc);
  387. void outport(unsigned port,int word);
  388. void outportb(int port,charc);
  389. char *parsfnm(char *filename,struct fcb *buffer,int option);
  390.  
  391.  
  392.  
  393. ?«dos.h_3»
  394. #include<dos.h>;
  395. int peek(unsigned segment,unsigned offset);
  396. int peekb(unsigned segment,unsigned offset);
  397. void poke(unsigned segment,unsigned offset,int value);
  398. void pokeb(unsigned segment,unsigned offset,char value);
  399. void segread(struct SREGS *sregs);
  400. int setblock(unsigned seg,unsigned size);
  401. int setcbrk(int flag);
  402. void setdate(struct date *datebuf);
  403. void setdta(char far *address);
  404. void settime(struct time *timebuf);
  405. void setvect(int intno,void interrupt (far *handler)());
  406. void setverify(int flag);
  407. void sleep(unsigned seconds);
  408. void unixtodos(time_t timer, struct date *dosdate, struct time *dostime);
  409.  
  410.  
  411.  
  412. ?«ctype.h»
  413. #include<ctype.h>;
  414. int isalnum(int c);
  415. int isalpha(int c);
  416. int iscntrl(int c);
  417. int isdigit(int c);
  418. int isgraph(int c);
  419. int islower(int c);
  420. int isprint(int c);
  421. int ispunct(int c);
  422. int isspace(int c);
  423. int isupper(int c);
  424. int isxdigit(int c);
  425. int tolower(int c);
  426. int toupper(int c);
  427. int  isascii(int c);
  428. int  isatty(int fd);
  429. int  toascii(int c);
  430. int _tolower(int c);
  431. int _toupper(int c);
  432.  
  433.  
  434.  
  435. ?«direct.h»
  436. #include <direct.h>;
  437. int chdir(char *path);
  438. int findfirst(char *filename, struct ffblk *filedata, int attr);
  439. int findnext(struct ffblk *filedata);
  440. void fnmerge(char *path, char *drive, char *dir, char *file, char *ext);
  441. int fnsplit(char *path, char *drive, char *dir, char *file, char *ext);
  442. int getcurdir(int drive, char *dirname);
  443. char *getcwd(char *path, int length);
  444. int getdisk(void);
  445. int mkdir(char *path);
  446. char *mktemp(char *template);
  447. int rmdir(char *name);
  448. char *searchpath(char *filename);
  449. int setdisk(int drive);
  450.  
  451.  
  452.  
  453.  
  454. ?«float.h»
  455. #include<float.h>;
  456. unsigned _clear87(void);
  457. unsigned _control87(unsigned cw, unsigned mask);
  458. void     _fpreset(void);
  459. unsigned _status87(void);
  460.  
  461.  
  462. ?«graphics.h»
  463. #include <graphics.h>;
  464. void  box(int width, int height, int fillflag);
  465. void  circle(int radius, int color);
  466. void  clrscrn2(int color);
  467. void  ellipse(int xradius, int yradius, int color);
  468. void  fill(int bordercolor);
  469. void  fill_style(char *colors, int width, int height);
  470. void  flood(int width,int height);
  471. int  getpixel(int x, int y);
  472. int  getvmode(void);
  473. struct vconfig *getvconfig(struct vconfig *screen);
  474. void  line_by(int xoffset, int yoffset);
  475. void  line_style(char *colors, int size);
  476. void  line_to(int x, int y);
  477. void  move_by(int xoffset, int yoffset);
  478. void  move_to(int x, int y);
  479. int  pen_color(int color);
  480. void  pie(int radius, double *data, int pieces,
  481.       struct fill_pattern *fillpat);
  482. void  plotch(int ch);
  483. void  plots(char *string);
  484. int  readdot(int row, int col);
  485. int  setapage(int pageno);
  486. void  setcolor(int background, int palette);
  487. int  setvpage(int pageno);
  488. void  setpixel(int x, int y);
  489. int  setvmode(int mode);
  490. void  writedot(int row, int col, int pixel);
  491.  
  492.  
  493.  
  494. ?«io.h»
  495. #include <io.h>;
  496. int access(char *filename, int mode);
  497. int chmod(char *filename, int permission);
  498. int chsize(int fd, long size);
  499. int close(int fd);
  500. int creat(char *filename, int mode);
  501. int dup(int fd);
  502. int dup2(int fd1, int fd2);
  503. int eof(int fd);
  504. longfilelength(int fd);
  505. int getftime(int fd, struct ftime *date);
  506. int ioctl(int fd, int operation, ... /* void *dx, int cx */);
  507. int locking(int fd, int mode, long size);
  508. long lseek(int fd, long offset, int origin);
  509. char   *mktemp(char *template);
  510. int open(char *filename, int access, ... /* int mode */);
  511. int read(int fd, char *buffer, unsigned number);
  512. int remove(char *filename);
  513. int rename(char *oldname, char *newname);
  514. int setftime(int fd, struct ftime *date);
  515. int setmode(int fd, int mode);
  516. int sopen(char *filename, int access, int shared, ... /* int mode */);
  517. long tell(int *fd);
  518. int umask(int mode);
  519. int unlink(char *filename);
  520. int write(int fd, char*buffer, int number);
  521.  
  522.  
  523.  
  524. ?«math.h»
  525. #include <math.h>;
  526. double acos(double x);
  527. double asin(double x);
  528. double atan(double x);
  529. double atan2(double y,double x);
  530. double cos(double x);
  531. double cosh(double x);
  532. double exp(double x);
  533. double fabs(double x);
  534. double floor(double x);
  535. double fmod(double x, double y);
  536. double frexp(double x,int *exp);
  537. double hypot(double x,double y);
  538. double ldexp(double x,int exp);
  539. double log(double x);
  540. double log10(double x);
  541. double modf(double x, double *wholepart);
  542. double pow(double x, double y);
  543. double sin(double x);
  544. double sinh(double x);
  545. double sqrt(double x);
  546. double tan(double x);
  547. double tanh(double x);
  548. extern int errno;
  549. extern char _mathmsg;
  550. double cabs(struct complex z);
  551. double ceil(double x);
  552. double j0(double x);
  553. double j1(double x);
  554. double jn(int n, double x);
  555. int    matherr(struct exception *err);
  556. double poly(double x, int degree, double coeff[]);
  557. double pow10(int n);
  558. double y0(double x);
  559. double y1(double x);
  560. double yn(int n, double x);
  561.  
  562.  
  563.  
  564. ?«memory.h»
  565. #include <memory.h>;
  566. void exitmsg(void);
  567. void   *memccpy(void *destaddr, void *srcaddr, int c, size_t n);
  568. void   *memchr(void *addr, int c, size_t n);
  569. int memcmp(void *addr1, void *addr2, size_t n);
  570. int memcpy(void *destaddr, void *srcaddr, size_t n);
  571. int memicmp(void *addr1, void *addr2, size_t n);
  572. int memmove(void *destaddr, void *srcaddr, size_t n);
  573. void *memset(void *addr, int c, size_t n);
  574. void movedata(int srcseg, int srcoff,
  575.    int destseg, int destoff, unsigned size);
  576. void repmem(void *address, void *data, int size, int number);
  577. void setmem(void *addr, intn, char c);
  578.  
  579.  
  580.  
  581. ?«search.h»
  582. #include <search.h>;
  583. void *bsearch(void *key, void *base, size_t number, size_t size,
  584.       int (*compare)(void *, void *));
  585. char *lfind(void *key,void *base, unsigned *number, unsigned size,
  586.       int (*compare)(void *, void *));
  587. char *lsearch(void *key, void *base, unsigned *number, unsigned size,
  588.       int (*compare)(void *, void *));
  589. void qsort(void *base,size_t number, size_t size,
  590.       int(*compare)(void *, void *));
  591.  
  592.  
  593.  
  594. ?«setjmp.h»
  595. #include <setjump.h>;
  596. void longjmp(jmp_buf env, int value);
  597. int setjmp(jmp_buf env);
  598.  
  599.  
  600.  
  601. ?«signal.h»
  602. #include <signal.h>;
  603. void (*signal(int sig,void (*sighandler)(int)))(int);
  604. int raise(int sig);
  605.  
  606.  
  607.  
  608. ?«time.h»
  609. #include <time.h>;
  610. char *asctime(struct tm *timeptr);
  611. clock_t clock(void);
  612. char *ctime(time_t *timer);
  613. double difftime(time_ttime2, time_t time1);
  614. struct tm *gmtime(time_t *timer);
  615. struct tm *localtime(time_t *timer);
  616. time_t mktime(struct tm *timeptr);
  617. size_t strftime(char *buffer, size_t bufsize,
  618.             char *format,struct tm *timeptr);
  619. time_t time(time_t *timer);
  620. void ftime(struct timeb *timeptr);
  621. void getdate(struct date *datebuf);
  622. void gettime(struct time *timebuf);
  623. void setdate(struct date *datebuf);
  624. void settime(struct time *timebuf);
  625. int stime(time_t *timer);
  626. void tzset(void);
  627.